home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / include / bits / wchar2.h < prev    next >
C/C++ Source or Header  |  2009-10-07  |  21KB  |  591 lines
  1. /* Checking macros for wchar functions.
  2.    Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
  3.    This file is part of the GNU C Library.
  4.  
  5.    The GNU C Library is free software; you can redistribute it and/or
  6.    modify it under the terms of the GNU Lesser General Public
  7.    License as published by the Free Software Foundation; either
  8.    version 2.1 of the License, or (at your option) any later version.
  9.  
  10.    The GNU C Library is distributed in the hope that it will be useful,
  11.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.    Lesser General Public License for more details.
  14.  
  15.    You should have received a copy of the GNU Lesser General Public
  16.    License along with the GNU C Library; if not, write to the Free
  17.    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18.    02111-1307 USA.  */
  19.  
  20. #ifndef _WCHAR_H
  21. # error "Never include <bits/wchar2.h> directly; use <wchar.h> instead."
  22. #endif
  23.  
  24.  
  25. extern wchar_t *__wmemcpy_chk (wchar_t *__restrict __s1,
  26.                    __const wchar_t *__restrict __s2, size_t __n,
  27.                    size_t __ns1) __THROW;
  28. extern wchar_t *__REDIRECT_NTH (__wmemcpy_alias,
  29.                 (wchar_t *__restrict __s1,
  30.                  __const wchar_t *__restrict __s2, size_t __n),
  31.                 wmemcpy);
  32. extern wchar_t *__REDIRECT_NTH (__wmemcpy_chk_warn,
  33.                 (wchar_t *__restrict __s1,
  34.                  __const wchar_t *__restrict __s2, size_t __n,
  35.                  size_t __ns1), __wmemcpy_chk)
  36.      __warnattr ("wmemcpy called with length bigger than size of destination "
  37.          "buffer");
  38.  
  39. __extern_always_inline wchar_t *
  40. __NTH (wmemcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2,
  41.         size_t __n))
  42. {
  43.   if (__bos0 (__s1) != (size_t) -1)
  44.     {
  45.       if (!__builtin_constant_p (__n))
  46.     return __wmemcpy_chk (__s1, __s2, __n,
  47.                   __bos0 (__s1) / sizeof (wchar_t));
  48.  
  49.       if (__n > __bos0 (__s1) / sizeof (wchar_t))
  50.     return __wmemcpy_chk_warn (__s1, __s2, __n,
  51.                    __bos0 (__s1) / sizeof (wchar_t));
  52.     }
  53.   return __wmemcpy_alias (__s1, __s2, __n);
  54. }
  55.  
  56.  
  57. extern wchar_t *__wmemmove_chk (wchar_t *__s1, __const wchar_t *__s2,
  58.                 size_t __n, size_t __ns1) __THROW;
  59. extern wchar_t *__REDIRECT_NTH (__wmemmove_alias, (wchar_t *__s1,
  60.                            __const wchar_t *__s2,
  61.                            size_t __n), wmemmove);
  62. extern wchar_t *__REDIRECT_NTH (__wmemmove_chk_warn,
  63.                 (wchar_t *__restrict __s1,
  64.                  __const wchar_t *__restrict __s2, size_t __n,
  65.                  size_t __ns1), __wmemmove_chk)
  66.      __warnattr ("wmemmove called with length bigger than size of destination "
  67.          "buffer");
  68.  
  69. __extern_always_inline wchar_t *
  70. __NTH (wmemmove (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2,
  71.          size_t __n))
  72. {
  73.   if (__bos0 (__s1) != (size_t) -1)
  74.     {
  75.       if (!__builtin_constant_p (__n))
  76.     return __wmemmove_chk (__s1, __s2, __n,
  77.                    __bos0 (__s1) / sizeof (wchar_t));
  78.  
  79.       if (__n > __bos0 (__s1) / sizeof (wchar_t))
  80.     return __wmemmove_chk_warn (__s1, __s2, __n,
  81.                     __bos0 (__s1) / sizeof (wchar_t));
  82.     }
  83.   return __wmemmove_alias (__s1, __s2, __n);
  84. }
  85.  
  86.  
  87. #ifdef __USE_GNU
  88. extern wchar_t *__wmempcpy_chk (wchar_t *__restrict __s1,
  89.                 __const wchar_t *__restrict __s2, size_t __n,
  90.                 size_t __ns1) __THROW;
  91. extern wchar_t *__REDIRECT_NTH (__wmempcpy_alias,
  92.                 (wchar_t *__restrict __s1,
  93.                  __const wchar_t *__restrict __s2,
  94.                  size_t __n), wmempcpy);
  95. extern wchar_t *__REDIRECT_NTH (__wmempcpy_chk_warn,
  96.                 (wchar_t *__restrict __s1,
  97.                  __const wchar_t *__restrict __s2, size_t __n,
  98.                  size_t __ns1), __wmempcpy_chk)
  99.      __warnattr ("wmempcpy called with length bigger than size of destination "
  100.          "buffer");
  101.  
  102. __extern_always_inline wchar_t *
  103. __NTH (wmempcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2,
  104.          size_t __n))
  105. {
  106.   if (__bos0 (__s1) != (size_t) -1)
  107.     {
  108.       if (!__builtin_constant_p (__n))
  109.     return __wmempcpy_chk (__s1, __s2, __n,
  110.                    __bos0 (__s1) / sizeof (wchar_t));
  111.  
  112.       if (__n > __bos0 (__s1) / sizeof (wchar_t))
  113.     return __wmempcpy_chk_warn (__s1, __s2, __n,
  114.                     __bos0 (__s1) / sizeof (wchar_t));
  115.     }
  116.   return __wmempcpy_alias (__s1, __s2, __n);
  117. }
  118. #endif
  119.  
  120.  
  121. extern wchar_t *__wmemset_chk (wchar_t *__s, wchar_t __c, size_t __n,
  122.                    size_t __ns) __THROW;
  123. extern wchar_t *__REDIRECT_NTH (__wmemset_alias, (wchar_t *__s, wchar_t __c,
  124.                           size_t __n), wmemset);
  125. extern wchar_t *__REDIRECT_NTH (__wmemset_chk_warn,
  126.                 (wchar_t *__s, wchar_t __c, size_t __n,
  127.                  size_t __ns), __wmemset_chk)
  128.      __warnattr ("wmemset called with length bigger than size of destination "
  129.          "buffer");
  130.  
  131. __extern_always_inline wchar_t *
  132. __NTH (wmemset (wchar_t *__restrict __s, wchar_t __c, size_t __n))
  133. {
  134.   if (__bos0 (__s) != (size_t) -1)
  135.     {
  136.       if (!__builtin_constant_p (__n))
  137.     return __wmemset_chk (__s, __c, __n, __bos0 (__s) / sizeof (wchar_t));
  138.  
  139.       if (__n > __bos0 (__s) / sizeof (wchar_t))
  140.     return __wmemset_chk_warn (__s, __c, __n,
  141.                    __bos0 (__s) / sizeof (wchar_t));
  142.     }
  143.   return __wmemset_alias (__s, __c, __n);
  144. }
  145.  
  146.  
  147. extern wchar_t *__wcscpy_chk (wchar_t *__restrict __dest,
  148.                   __const wchar_t *__restrict __src,
  149.                   size_t __n) __THROW;
  150. extern wchar_t *__REDIRECT_NTH (__wcscpy_alias,
  151.                 (wchar_t *__restrict __dest,
  152.                  __const wchar_t *__restrict __src), wcscpy);
  153.  
  154. __extern_always_inline wchar_t *
  155. __NTH (wcscpy (wchar_t *__dest, __const wchar_t *__src))
  156. {
  157.   if (__bos (__dest) != (size_t) -1)
  158.     return __wcscpy_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t));
  159.   return __wcscpy_alias (__dest, __src);
  160. }
  161.  
  162.  
  163. extern wchar_t *__wcpcpy_chk (wchar_t *__dest, __const wchar_t *__src,
  164.                   size_t __destlen) __THROW;
  165. extern wchar_t *__REDIRECT_NTH (__wcpcpy_alias, (wchar_t *__dest,
  166.                          __const wchar_t *__src),
  167.                 wcpcpy);
  168.  
  169. __extern_always_inline wchar_t *
  170. __NTH (wcpcpy (wchar_t *__dest, __const wchar_t *__src))
  171. {
  172.   if (__bos (__dest) != (size_t) -1)
  173.     return __wcpcpy_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t));
  174.   return __wcpcpy_alias (__dest, __src);
  175. }
  176.  
  177.  
  178. extern wchar_t *__wcsncpy_chk (wchar_t *__restrict __dest,
  179.                    __const wchar_t *__restrict __src, size_t __n,
  180.                    size_t __destlen) __THROW;
  181. extern wchar_t *__REDIRECT_NTH (__wcsncpy_alias,
  182.                 (wchar_t *__restrict __dest,
  183.                  __const wchar_t *__restrict __src,
  184.                  size_t __n), wcsncpy);
  185. extern wchar_t *__REDIRECT_NTH (__wcsncpy_chk_warn,
  186.                 (wchar_t *__restrict __dest,
  187.                  __const wchar_t *__restrict __src,
  188.                  size_t __n, size_t __destlen), __wcsncpy_chk)
  189.      __warnattr ("wcsncpy called with length bigger than size of destination "
  190.          "buffer");
  191.  
  192. __extern_always_inline wchar_t *
  193. __NTH (wcsncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n))
  194. {
  195.   if (__bos (__dest) != (size_t) -1)
  196.     {
  197.       if (!__builtin_constant_p (__n))
  198.     return __wcsncpy_chk (__dest, __src, __n,
  199.                   __bos (__dest) / sizeof (wchar_t));
  200.       if (__n > __bos (__dest) / sizeof (wchar_t))
  201.     return __wcsncpy_chk_warn (__dest, __src, __n,
  202.                    __bos (__dest) / sizeof (wchar_t));
  203.     }
  204.   return __wcsncpy_alias (__dest, __src, __n);
  205. }
  206.  
  207.  
  208. extern wchar_t *__wcpncpy_chk (wchar_t *__restrict __dest,
  209.                    __const wchar_t *__restrict __src, size_t __n,
  210.                    size_t __destlen) __THROW;
  211. extern wchar_t *__REDIRECT_NTH (__wcpncpy_alias,
  212.                 (wchar_t *__restrict __dest,
  213.                  __const wchar_t *__restrict __src,
  214.                  size_t __n), wcpncpy);
  215. extern wchar_t *__REDIRECT_NTH (__wcpncpy_chk_warn,
  216.                 (wchar_t *__restrict __dest,
  217.                  __const wchar_t *__restrict __src,
  218.                  size_t __n, size_t __destlen), __wcpncpy_chk)
  219.      __warnattr ("wcpncpy called with length bigger than size of destination "
  220.          "buffer");
  221.  
  222. __extern_always_inline wchar_t *
  223. __NTH (wcpncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n))
  224. {
  225.   if (__bos (__dest) != (size_t) -1)
  226.     {
  227.       if (!__builtin_constant_p (__n))
  228.     return __wcpncpy_chk (__dest, __src, __n,
  229.                   __bos (__dest) / sizeof (wchar_t));
  230.       if (__n > __bos (__dest) / sizeof (wchar_t))
  231.     return __wcpncpy_chk_warn (__dest, __src, __n,
  232.                    __bos (__dest) / sizeof (wchar_t));
  233.     }
  234.   return __wcpncpy_alias (__dest, __src, __n);
  235. }
  236.  
  237.  
  238. extern wchar_t *__wcscat_chk (wchar_t *__restrict __dest,
  239.                   __const wchar_t *__restrict __src,
  240.                   size_t __destlen) __THROW;
  241. extern wchar_t *__REDIRECT_NTH (__wcscat_alias,
  242.                 (wchar_t *__restrict __dest,
  243.                  __const wchar_t *__restrict __src), wcscat);
  244.  
  245. __extern_always_inline wchar_t *
  246. __NTH (wcscat (wchar_t *__dest, __const wchar_t *__src))
  247. {
  248.   if (__bos (__dest) != (size_t) -1)
  249.     return __wcscat_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t));
  250.   return __wcscat_alias (__dest, __src);
  251. }
  252.  
  253.  
  254. extern wchar_t *__wcsncat_chk (wchar_t *__restrict __dest,
  255.                    __const wchar_t *__restrict __src,
  256.                    size_t __n, size_t __destlen) __THROW;
  257. extern wchar_t *__REDIRECT_NTH (__wcsncat_alias,
  258.                 (wchar_t *__restrict __dest,
  259.                  __const wchar_t *__restrict __src,
  260.                  size_t __n), wcsncat);
  261.  
  262. __extern_always_inline wchar_t *
  263. __NTH (wcsncat (wchar_t *__dest, __const wchar_t *__src, size_t __n))
  264. {
  265.   if (__bos (__dest) != (size_t) -1)
  266.     return __wcsncat_chk (__dest, __src, __n,
  267.               __bos (__dest) / sizeof (wchar_t));
  268.   return __wcsncat_alias (__dest, __src, __n);
  269. }
  270.  
  271.  
  272. extern int __swprintf_chk (wchar_t *__restrict __s, size_t __n,
  273.                int __flag, size_t __s_len,
  274.                __const wchar_t *__restrict __format, ...)
  275.      __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 6))) */;
  276.  
  277. extern int __REDIRECT_NTH_LDBL (__swprintf_alias,
  278.                 (wchar_t *__restrict __s, size_t __n,
  279.                  __const wchar_t *__restrict __fmt, ...),
  280.                 swprintf);
  281.  
  282. #ifdef __va_arg_pack
  283. __extern_always_inline int
  284. __NTH (swprintf (wchar_t *__restrict __s, size_t __n,
  285.          __const wchar_t *__restrict __fmt, ...))
  286. {
  287.   if (__bos (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1)
  288.     return __swprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
  289.                __bos (__s) / sizeof (wchar_t),
  290.                __fmt, __va_arg_pack ());
  291.   return __swprintf_alias (__s, __n, __fmt, __va_arg_pack ());
  292. }
  293. #elif !defined __cplusplus
  294. /* XXX We might want to have support in gcc for swprintf.  */
  295. # define swprintf(s, n, ...) \
  296.   (__bos (s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1                  \
  297.    ? __swprintf_chk (s, n, __USE_FORTIFY_LEVEL - 1,                  \
  298.              __bos (s) / sizeof (wchar_t), __VA_ARGS__)              \
  299.    : swprintf (s, n, __VA_ARGS__))
  300. #endif
  301.  
  302. extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n,
  303.                 int __flag, size_t __s_len,
  304.                 __const wchar_t *__restrict __format,
  305.                 __gnuc_va_list __arg)
  306.      __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 0))) */;
  307.  
  308. extern int __REDIRECT_NTH_LDBL (__vswprintf_alias,
  309.                 (wchar_t *__restrict __s, size_t __n,
  310.                  __const wchar_t *__restrict __fmt,
  311.                  __gnuc_va_list __ap), vswprintf);
  312.  
  313. __extern_always_inline int
  314. __NTH (vswprintf (wchar_t *__restrict __s, size_t __n,
  315.           __const wchar_t *__restrict __fmt, __gnuc_va_list __ap))
  316. {
  317.   if (__bos (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1)
  318.     return __vswprintf_chk (__s, __n,  __USE_FORTIFY_LEVEL - 1,
  319.                 __bos (__s) / sizeof (wchar_t), __fmt, __ap);
  320.   return __vswprintf_alias (__s, __n, __fmt, __ap);
  321. }
  322.  
  323.  
  324. #if __USE_FORTIFY_LEVEL > 1
  325.  
  326. extern int __fwprintf_chk (__FILE *__restrict __stream, int __flag,
  327.                __const wchar_t *__restrict __format, ...);
  328. extern int __wprintf_chk (int __flag, __const wchar_t *__restrict __format,
  329.               ...);
  330. extern int __vfwprintf_chk (__FILE *__restrict __stream, int __flag,
  331.                 __const wchar_t *__restrict __format,
  332.                 __gnuc_va_list __ap);
  333. extern int __vwprintf_chk (int __flag, __const wchar_t *__restrict __format,
  334.                __gnuc_va_list __ap);
  335.  
  336. # ifdef __va_arg_pack
  337. __extern_always_inline int
  338. wprintf (__const wchar_t *__restrict __fmt, ...)
  339. {
  340.   return __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ());
  341. }
  342.  
  343. __extern_always_inline int
  344. fwprintf (__FILE *__restrict __stream, __const wchar_t *__restrict __fmt, ...)
  345. {
  346.   return __fwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt,
  347.              __va_arg_pack ());
  348. }
  349. # elif !defined __cplusplus
  350. #  define wprintf(...) \
  351.   __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __VA_ARGS__)
  352. #  define fwprintf(stream, ...) \
  353.   __fwprintf_chk (stream, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__)
  354. # endif
  355.  
  356. __extern_always_inline int
  357. vwprintf (__const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
  358. {
  359.   return __vwprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __ap);
  360. }
  361.  
  362. __extern_always_inline int
  363. vfwprintf (__FILE *__restrict __stream,
  364.        __const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
  365. {
  366.   return __vfwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, __ap);
  367. }
  368.  
  369. #endif
  370.  
  371. extern wchar_t *__fgetws_chk (wchar_t *__restrict __s, size_t __size, int __n,
  372.                   __FILE *__restrict __stream) __wur;
  373. extern wchar_t *__REDIRECT (__fgetws_alias,
  374.                 (wchar_t *__restrict __s, int __n,
  375.                  __FILE *__restrict __stream), fgetws) __wur;
  376. extern wchar_t *__REDIRECT (__fgetws_chk_warn,
  377.                 (wchar_t *__restrict __s, size_t __size, int __n,
  378.                  __FILE *__restrict __stream), __fgetws_chk)
  379.      __wur __warnattr ("fgetws called with bigger size than length "
  380.                "of destination buffer");
  381.  
  382. __extern_always_inline __wur wchar_t *
  383. fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
  384. {
  385.   if (__bos (__s) != (size_t) -1)
  386.     {
  387.       if (!__builtin_constant_p (__n) || __n <= 0)
  388.     return __fgetws_chk (__s, __bos (__s) / sizeof (wchar_t),
  389.                  __n, __stream);
  390.  
  391.       if ((size_t) __n > __bos (__s) / sizeof (wchar_t))
  392.     return __fgetws_chk_warn (__s, __bos (__s) / sizeof (wchar_t),
  393.                   __n, __stream);
  394.     }
  395.   return __fgetws_alias (__s, __n, __stream);
  396. }
  397.  
  398. #ifdef __USE_GNU
  399. extern wchar_t *__fgetws_unlocked_chk (wchar_t *__restrict __s, size_t __size,
  400.                        int __n, __FILE *__restrict __stream)
  401.   __wur;
  402. extern wchar_t *__REDIRECT (__fgetws_unlocked_alias,
  403.                 (wchar_t *__restrict __s, int __n,
  404.                  __FILE *__restrict __stream), fgetws_unlocked)
  405.   __wur;
  406. extern wchar_t *__REDIRECT (__fgetws_unlocked_chk_warn,
  407.                 (wchar_t *__restrict __s, size_t __size, int __n,
  408.                  __FILE *__restrict __stream),
  409.                 __fgetws_unlocked_chk)
  410.      __wur __warnattr ("fgetws_unlocked called with bigger size than length "
  411.                "of destination buffer");
  412.  
  413. __extern_always_inline __wur wchar_t *
  414. fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
  415. {
  416.   if (__bos (__s) != (size_t) -1)
  417.     {
  418.       if (!__builtin_constant_p (__n) || __n <= 0)
  419.     return __fgetws_unlocked_chk (__s, __bos (__s) / sizeof (wchar_t),
  420.                       __n, __stream);
  421.  
  422.       if ((size_t) __n > __bos (__s) / sizeof (wchar_t))
  423.     return __fgetws_unlocked_chk_warn (__s, __bos (__s) / sizeof (wchar_t),
  424.                        __n, __stream);
  425.     }
  426.   return __fgetws_unlocked_alias (__s, __n, __stream);
  427. }
  428. #endif
  429.  
  430.  
  431. extern size_t __wcrtomb_chk (char *__s, wchar_t __wchar, mbstate_t *__p,
  432.               size_t __buflen) __THROW __wur;
  433. extern size_t __REDIRECT_NTH (__wcrtomb_alias,
  434.                   (char *__restrict __s, wchar_t __wchar,
  435.                    mbstate_t *__restrict __ps), wcrtomb) __wur;
  436.  
  437. __extern_always_inline __wur size_t
  438. __NTH (wcrtomb (char *__s, wchar_t __wchar, mbstate_t *__ps))
  439. {
  440.   /* We would have to include <limits.h> to get a definition of MB_LEN_MAX.
  441.      But this would only disturb the namespace.  So we define our own
  442.      version here.  */
  443. #define __WCHAR_MB_LEN_MAX    16
  444. #if defined MB_LEN_MAX && MB_LEN_MAX != __WCHAR_MB_LEN_MAX
  445. # error "Assumed value of MB_LEN_MAX wrong"
  446. #endif
  447.   if (__bos (__s) != (size_t) -1 && __WCHAR_MB_LEN_MAX > __bos (__s))
  448.     return __wcrtomb_chk (__s, __wchar, __ps, __bos (__s));
  449.   return __wcrtomb_alias (__s, __wchar, __ps);
  450. }
  451.  
  452.  
  453. extern size_t __mbsrtowcs_chk (wchar_t *__restrict __dst,
  454.                    __const char **__restrict __src,
  455.                    size_t __len, mbstate_t *__restrict __ps,
  456.                    size_t __dstlen) __THROW;
  457. extern size_t __REDIRECT_NTH (__mbsrtowcs_alias,
  458.                   (wchar_t *__restrict __dst,
  459.                    __const char **__restrict __src,
  460.                    size_t __len, mbstate_t *__restrict __ps),
  461.                   mbsrtowcs);
  462. extern size_t __REDIRECT_NTH (__mbsrtowcs_chk_warn,
  463.                   (wchar_t *__restrict __dst,
  464.                    __const char **__restrict __src,
  465.                    size_t __len, mbstate_t *__restrict __ps,
  466.                    size_t __dstlen), __mbsrtowcs_chk)
  467.      __warnattr ("mbsrtowcs called with dst buffer smaller than len "
  468.          "* sizeof (wchar_t)");
  469.  
  470. __extern_always_inline size_t
  471. __NTH (mbsrtowcs (wchar_t *__restrict __dst, __const char **__restrict __src,
  472.           size_t __len, mbstate_t *__restrict __ps))
  473. {
  474.   if (__bos (__dst) != (size_t) -1)
  475.     {
  476.       if (!__builtin_constant_p (__len))
  477.     return __mbsrtowcs_chk (__dst, __src, __len, __ps,
  478.                 __bos (__dst) / sizeof (wchar_t));
  479.  
  480.       if (__len > __bos (__dst) / sizeof (wchar_t))
  481.     return __mbsrtowcs_chk_warn (__dst, __src, __len, __ps,
  482.                      __bos (__dst) / sizeof (wchar_t));
  483.     }
  484.   return __mbsrtowcs_alias (__dst, __src, __len, __ps);
  485. }
  486.  
  487.  
  488. extern size_t __wcsrtombs_chk (char *__restrict __dst,
  489.                    __const wchar_t **__restrict __src,
  490.                    size_t __len, mbstate_t *__restrict __ps,
  491.                    size_t __dstlen) __THROW;
  492. extern size_t __REDIRECT_NTH (__wcsrtombs_alias,
  493.                   (char *__restrict __dst,
  494.                    __const wchar_t **__restrict __src,
  495.                    size_t __len, mbstate_t *__restrict __ps),
  496.                   wcsrtombs);
  497. extern size_t __REDIRECT_NTH (__wcsrtombs_chk_warn,
  498.                   (char *__restrict __dst,
  499.                    __const wchar_t **__restrict __src,
  500.                    size_t __len, mbstate_t *__restrict __ps,
  501.                    size_t __dstlen), __wcsrtombs_chk)
  502.     __warnattr ("wcsrtombs called with dst buffer smaller than len");
  503.  
  504. __extern_always_inline size_t
  505. __NTH (wcsrtombs (char *__restrict __dst, __const wchar_t **__restrict __src,
  506.           size_t __len, mbstate_t *__restrict __ps))
  507. {
  508.   if (__bos (__dst) != (size_t) -1)
  509.     {
  510.       if (!__builtin_constant_p (__len))
  511.     return __wcsrtombs_chk (__dst, __src, __len, __ps, __bos (__dst));
  512.  
  513.       if (__len > __bos (__dst))
  514.     return __wcsrtombs_chk_warn (__dst, __src, __len, __ps, __bos (__dst));
  515.     }
  516.   return __wcsrtombs_alias (__dst, __src, __len, __ps);
  517. }
  518.  
  519.  
  520. #ifdef __USE_GNU
  521. extern size_t __mbsnrtowcs_chk (wchar_t *__restrict __dst,
  522.                 __const char **__restrict __src, size_t __nmc,
  523.                 size_t __len, mbstate_t *__restrict __ps,
  524.                 size_t __dstlen) __THROW;
  525. extern size_t __REDIRECT_NTH (__mbsnrtowcs_alias,
  526.                   (wchar_t *__restrict __dst,
  527.                    __const char **__restrict __src, size_t __nmc,
  528.                    size_t __len, mbstate_t *__restrict __ps),
  529.                   mbsnrtowcs);
  530. extern size_t __REDIRECT_NTH (__mbsnrtowcs_chk_warn,
  531.                   (wchar_t *__restrict __dst,
  532.                    __const char **__restrict __src, size_t __nmc,
  533.                    size_t __len, mbstate_t *__restrict __ps,
  534.                    size_t __dstlen), __mbsnrtowcs_chk)
  535.      __warnattr ("mbsnrtowcs called with dst buffer smaller than len "
  536.          "* sizeof (wchar_t)");
  537.  
  538. __extern_always_inline size_t
  539. __NTH (mbsnrtowcs (wchar_t *__restrict __dst, __const char **__restrict __src,
  540.            size_t __nmc, size_t __len, mbstate_t *__restrict __ps))
  541. {
  542.   if (__bos (__dst) != (size_t) -1)
  543.     {
  544.       if (!__builtin_constant_p (__len))
  545.     return __mbsnrtowcs_chk (__dst, __src, __nmc, __len, __ps,
  546.                  __bos (__dst) / sizeof (wchar_t));
  547.  
  548.       if (__len > __bos (__dst) / sizeof (wchar_t))
  549.     return __mbsnrtowcs_chk_warn (__dst, __src, __nmc, __len, __ps,
  550.                       __bos (__dst) / sizeof (wchar_t));
  551.     }
  552.   return __mbsnrtowcs_alias (__dst, __src, __nmc, __len, __ps);
  553. }
  554.  
  555.  
  556. extern size_t __wcsnrtombs_chk (char *__restrict __dst,
  557.                 __const wchar_t **__restrict __src,
  558.                 size_t __nwc, size_t __len,
  559.                 mbstate_t *__restrict __ps, size_t __dstlen)
  560.      __THROW;
  561. extern size_t __REDIRECT_NTH (__wcsnrtombs_alias,
  562.                   (char *__restrict __dst,
  563.                    __const wchar_t **__restrict __src,
  564.                    size_t __nwc, size_t __len,
  565.                    mbstate_t *__restrict __ps), wcsnrtombs);
  566. extern size_t __REDIRECT_NTH (__wcsnrtombs_chk_warn,
  567.                   (char *__restrict __dst,
  568.                    __const wchar_t **__restrict __src,
  569.                    size_t __nwc, size_t __len,
  570.                    mbstate_t *__restrict __ps,
  571.                    size_t __dstlen), __wcsnrtombs_chk)
  572.      __warnattr ("wcsnrtombs called with dst buffer smaller than len");
  573.  
  574. __extern_always_inline size_t
  575. __NTH (wcsnrtombs (char *__restrict __dst, __const wchar_t **__restrict __src,
  576.            size_t __nwc, size_t __len, mbstate_t *__restrict __ps))
  577. {
  578.   if (__bos (__dst) != (size_t) -1)
  579.     {
  580.       if (!__builtin_constant_p (__len))
  581.     return __wcsnrtombs_chk (__dst, __src, __nwc, __len, __ps,
  582.                  __bos (__dst));
  583.  
  584.       if (__len > __bos (__dst))
  585.     return __wcsnrtombs_chk_warn (__dst, __src, __nwc, __len, __ps,
  586.                       __bos (__dst));
  587.     }
  588.   return __wcsnrtombs_alias (__dst, __src, __nwc, __len, __ps);
  589. }
  590. #endif
  591.